home *** CD-ROM | disk | FTP | other *** search
/ Resource for Source: C/C++ / Resource for Source - C-C++.iso / codelib6 / v_08_10 / 8n10055a < prev    next >
Encoding:
Text File  |  1995-11-01  |  22.8 KB  |  877 lines
  1. //////////////////////////////////////////////////////////////////////////
  2. //                                                                      //
  3. //                             ANTHILL                                  //
  4. //                                by                                    //
  5. //                     Mark Weaver and Alex Lane                        //
  6. //                                                                      //
  7. //////////////////////////////////////////////////////////////////////////
  8.  
  9. #include <graphics.h>
  10. #include <stdlib.h>
  11. #include <stdio.h>
  12. #include <conio.h>
  13. #include <math.h>
  14. #include <dos.h>
  15. #include <ctype.h>
  16. #include <string.h>
  17. #include "anthill.h"
  18.                     
  19. #define MIN(a,b)        (((a) < (b)) ? (a) : (b))
  20.  
  21. //////////////////////////////////////////////////////////////////////////
  22. //                                                                      //
  23. //                          Global Variables                            //
  24. //                                                                      //
  25. //////////////////////////////////////////////////////////////////////////
  26. float gfCellSizeX;              // Width (in pixels) of a cell
  27. float gfCellSizeY;              // Height (in pixels) of a cell
  28. unsigned guFoodUnits[100][100]; // How many units of food in each cell
  29. int gnTimeToHatch;              // Cycles required to become a worker ant
  30. int gnDropDistance;             // Distance at which to drop food for queen
  31. unsigned long gulTotalFood;     // Total units of food on board
  32. unsigned guWorkers;             // Total workers on board
  33. unsigned guEggs;                // Total number of eggs on board
  34. unsigned long gulCycle;         // Which life cycle are we in?
  35. unsigned guWorkersPortion;      // What a worker eats from each food packet
  36. unsigned guMaxLifeSpan;         // Longest life span
  37. unsigned guBirthRate;           // Percentage of cycles queen lays an egg
  38. unsigned guMaxSpeed;            // Maximum speed for worker ants
  39. unsigned guQueensEnergy;        // Queens extra starting energy level
  40. unsigned guInitEggs;            // Initial # of eggs
  41. unsigned guInitWorkers;         // Initial # of worker ants
  42. unsigned guInitFood;            // Initial # of cells with food
  43. unsigned guPause;               // Milliseconds to pause each cycle
  44. Queen *gQueen;                  // Queen ant
  45. Worker *headOfAntList;          // Head of linked list of worker ants
  46.  
  47.  
  48. //////////////////////////////////////////////////////////////////////////
  49. //                                                                      //
  50. //                        MOVER class functions                         //
  51. //                                                                      //
  52. //////////////////////////////////////////////////////////////////////////
  53.  
  54. Mover::Mover(unsigned uMaxRng, unsigned uMaxSpd, int nStartX, int nStartY)
  55. {
  56.   uMaxRange = uMaxRng;
  57.   uMaxSpeed = uMaxSpd;
  58.   nX = nInitX = nStartX;
  59.   nY = nInitY = nStartY;
  60.   bVisible = FALSE;
  61.   nVelX = -uMaxSpeed + random(uMaxSpeed + 1);
  62.   nVelY = -uMaxSpeed + random(uMaxSpeed + 1);
  63. }
  64.  
  65. int Mover::getX( void )
  66. {
  67. return nX;
  68. }
  69.  
  70. int Mover::getY( void )
  71. {
  72. return nY;
  73. }
  74.  
  75. BOOLEAN Mover::moveTo(int nNewX, int nNewY )
  76. {
  77.   if ((distance(nNewX, nNewY, nInitX, nInitY) <= uMaxRange || !uMaxRange)){
  78.     erase();
  79.      if ((nX = nNewX) < 0){
  80.         nX = 0;
  81.      }
  82.      else 
  83.         if (nX > 99) {
  84.             nX = 99;
  85.             }
  86.  
  87.      if ((nY = nNewY) < 0){
  88.         nY = 0;
  89.      }
  90.      else 
  91.         if (nY > 99) {
  92.         nY = 99;
  93.         }
  94.  
  95.      draw();
  96.      return( TRUE );
  97.   }
  98.   else {
  99.      return( FALSE );
  100.   }
  101. }
  102.  
  103. BOOLEAN Mover::move( void )
  104. {
  105.   int nNewX, nNewY;
  106.  
  107.   nNewX = nX + nVelX;
  108.   nNewY = nY + nVelY;
  109.  
  110.   if ((distance(nNewX, nNewY, nInitX, nInitY) <= uMaxRange || !uMaxRange)){
  111.     erase();
  112.      if ((nX = nNewX) < 0) {
  113.         nX = 0;
  114.         nVelX = -nVelX;
  115.      } 
  116.      else 
  117.         if (nX > 99) {
  118.             nX = 99;
  119.             nVelX = -nVelX;
  120.             }
  121.      if ((nY = nNewY) < 0) {
  122.         nY = 0;
  123.         nVelY = -nVelY;
  124.      }
  125.      else 
  126.         if (nY > 99) {
  127.         nY = 99;
  128.         nVelY = -nVelY;
  129.      }
  130.      draw();
  131.  
  132.     // Turn once in a while
  133.     if (random(100) < 10){
  134.       nVelX += random(3) - 1;
  135.       nVelY += random(3) - 1;
  136.         if (nVelX > uMaxSpeed) {
  137.           nVelX = uMaxSpeed;
  138.         }
  139.         else 
  140.             if (nVelX < -uMaxSpeed) {
  141.                 nVelX = -uMaxSpeed;
  142.             }
  143.  
  144.         if (nVelY > uMaxSpeed) { 
  145.           nVelY = uMaxSpeed;
  146.         }
  147.         else 
  148.             if (nVelY < -uMaxSpeed) {
  149.                 nVelY = -uMaxSpeed;
  150.             }
  151.  
  152.       // Make sure I do not stop
  153.         if (nVelX == 0 && nVelY == 0) {
  154.           nVelX = 1+random(uMaxSpeed-1);
  155.           nVelY = -1-random(uMaxSpeed-1);
  156.         }
  157.      }
  158.  
  159.      return( TRUE );
  160.   }
  161.   else {
  162.      draw();
  163.      return( FALSE );
  164.   }
  165. }
  166.  
  167. void Mover::show( void )
  168. {
  169.   if (!bVisible){
  170.      draw();
  171.      bVisible = TRUE;
  172.   }
  173. }
  174.  
  175. void Mover::erase( void )
  176. {
  177.   moverDrawFunc(nX, nY, FALSE, BACKGROUND );
  178. }
  179.  
  180. void Mover::draw( void )
  181. {
  182.   moverDrawFunc(nX, nY, TRUE, color);
  183. }
  184.  
  185. void Mover::moverDrawFunc(int nX, int nY, BOOLEAN bVisible, int nColor)
  186. {
  187.     setfillstyle(SOLID_FILL, bVisible ? nColor : BACKGROUND);
  188.     bar(nX * gfCellSizeX,        nY * gfCellSizeY,
  189.             (nX + 0.5) * gfCellSizeX, (nY + 1) * gfCellSizeY - 1);
  190. } 
  191.  
  192.  
  193. //////////////////////////////////////////////////////////////////////////
  194. //                                                                      //
  195. //                          ANT class functions                         //
  196. //                                                                      //
  197. //////////////////////////////////////////////////////////////////////////
  198.  
  199. Ant::Ant( int Range, int Speed, int nX, int nY, int Energy) :
  200.              Consumer( Energy ), // constructor 
  201.              Mover( Range, Speed, nX, nY ) // constructor
  202. {
  203.   bDead= FALSE;
  204. }
  205.  
  206. // Dying ant updates counters and drops any food he is carying
  207. void Ant::die(void)
  208. {
  209.   bDead = TRUE;
  210.   nEnergy = 0;
  211.   erase(); 
  212. }
  213.  
  214. void Ant::doTheAntThing(void)
  215. {
  216. // Age the ant
  217. nAge++;
  218.  
  219. // Every ant uses one energy unit per cycle
  220. nEnergy -= 1;
  221.  
  222. if (nEnergy<1 || nAge > nLifeSpan) {
  223.     die();
  224.     }
  225. else { 
  226.     if (bEgg) {
  227.         // force redraw in case egg has been walked on
  228.         moveTo(nX, nY); 
  229.         if (nAge > gnTimeToHatch) {
  230.             bEgg = FALSE;
  231.             color = GREEN;    
  232.             guEggs--;
  233.             guWorkers++;
  234.             }
  235.         }
  236.     }
  237. }
  238.  
  239. //////////////////////////////////////////////////////////////////////////
  240. //                                                                      //
  241. //                       QUEEN class functions                          //
  242. //                                                                      //
  243. //////////////////////////////////////////////////////////////////////////
  244.  
  245. Queen::Queen( unsigned InitEnergy, int QRange, int QSpeed, 
  246.                   int QIntitX, int QInitY, unsigned _birthRate ) : 
  247.     Ant(QRange, QSpeed, QIntitX, QInitY, random(100)+InitEnergy )
  248. {
  249.   birthRate = _birthRate;
  250.   color = YELLOW;
  251. }
  252.  
  253.  
  254. // Queen ant lays eggs once in a while
  255. void Queen::layEgg(void)
  256. {
  257.   new Worker(TRUE, nX, nY);
  258.   guEggs++;
  259.   nEnergy -= MIN(150, nEnergy);
  260. }
  261.  
  262.  
  263. void Queen::doTheAntThing(void)
  264. {
  265. // Every ant uses one energy unit per cycle
  266. nEnergy -= 1;
  267.  
  268. nVelX = random(uMaxSpeed+1)*(random(2) ? 1 : -1 );
  269. nVelY = random(uMaxSpeed+1)*(random(2) ? 1 : -1 );
  270.  
  271. if (nEnergy<1) {
  272.     die();
  273.     }
  274. else {
  275. // Turn around if at limits of area!
  276. if (distance(nInitX, nInitY, nX + nVelX, nY + nVelY) > uMaxRange) {
  277.     nVelX = -nVelX ;
  278.     nVelY = -nVelY ;
  279.     }
  280.                              
  281.     // Move somewhere
  282.     move();
  283.  
  284.     if (guFoodUnits[nX][nY]) {
  285.         eatFood(guFoodUnits[nX][nY]);
  286.         }
  287.     // need a minimum of 750 units to be able to lay an egg
  288.     // (the idea here is to conserve energy)
  289.     if ((nEnergy > 750) && (random(100) < birthRate)) {
  290.         layEgg();
  291.         }
  292.     // if the energy level gets too high, improve the chances of
  293.     // laying an egg; and vice versa
  294.     // keep the birthrate between 50 and 5 percent.
  295.     if ((nEnergy > 5000) && (birthRate < 49)) birthRate++;
  296.     if ((nEnergy < 3000) && (birthRate > 6)) birthRate--;
  297.     }
  298. }
  299.  
  300. //////////////////////////////////////////////////////////////////////////
  301. //                                                                      //
  302. //                       WORKER class functions                         //
  303. //                                                                      //
  304. //////////////////////////////////////////////////////////////////////////
  305.  
  306. Worker::Worker( BOOLEAN bEggYes, int nX, int nY ) : 
  307.              Ant( 0, guMaxSpeed, nX, nY, random(100)+50 )
  308. {
  309.   bEgg = bEggYes;
  310.   addToList();
  311.   nFood = 0;    // Start out carrying no food
  312.   // ants live for lifespan plus/minus 20%
  313.   nLifeSpan = (0.8 * guMaxLifeSpan) + random(0.4 * guMaxLifeSpan);
  314.  
  315.   if (bEggYes){
  316.      color = CYAN;
  317.      nAge = 0;
  318.   }else{
  319.      color = GREEN;
  320.      nAge = gnTimeToHatch + 1;
  321.   }
  322. }
  323.  
  324. Worker::~Worker(void)
  325. {
  326.   // Remove myself from the ant list
  327.   if (prevWorker == NULL) {
  328.      headOfAntList = nextWorker;
  329.   }
  330.   else {
  331.     prevWorker->nextWorker = nextWorker;
  332.   }
  333.   if (nextWorker != NULL) {
  334.     nextWorker->prevWorker = prevWorker;
  335.   }
  336. }
  337.  
  338. // Lie down and be counted (out)!!
  339. void Worker::die(void)
  340. {
  341.   // Drop any food before going to ant heaven
  342.   if (nFood) {
  343.      guFoodUnits[nX][nY] += nFood;
  344.   }
  345.   Ant::die();           // Call ant die function
  346.  
  347.   if (bEgg){
  348.      guEggs--;
  349.   }else{
  350.     guWorkers--;
  351.   }
  352. }
  353.  
  354.  
  355. // Add new ant to head of doubly linked list
  356. void Worker::addToList()
  357. {
  358.   // Place myself at the head of doubly linked list of ants
  359.   nextWorker = headOfAntList;
  360.   headOfAntList = this;
  361.   prevWorker = NULL;
  362.   if (nextWorker != NULL) {
  363.     nextWorker->prevWorker = this;
  364.   }
  365. }
  366.  
  367. // Drop food for the Queen to eat
  368. void Worker::dropFood(void)
  369. {
  370.   int xDist, yDist;
  371.  
  372.   guFoodUnits[nX][nY] += nFood;
  373.   nFood = 0;
  374.   color = GREEN;
  375.   showFood(nX, nY, TRUE);
  376.  
  377.   // Move AWAY from queen
  378.   if (nX < gQueen->getX()) {
  379.      xDist = -uMaxSpeed;
  380.   }
  381.   else 
  382.     if (nX > gQueen->getX()) {
  383.         xDist = uMaxSpeed;
  384.     }
  385.   if (nY < gQueen->getY()) {
  386.      yDist = -uMaxSpeed;
  387.   }
  388.   else 
  389.     if (nY > gQueen->getY()) {
  390.         yDist = uMaxSpeed;
  391.     }
  392.   moveTo(nX + xDist, nY + yDist);
  393. }
  394.  
  395. // Grab food to carry to queen, after eating a portion for self
  396. void Worker::grabFood(void)
  397. {
  398. // Eat some food to replenish energy
  399. eatFood(guWorkersPortion);
  400.  
  401. // Pick up rest to carry to queen
  402. nFood = guFoodUnits[nX][nY];
  403. guFoodUnits[nX][nY] = 0;
  404. showFood(nX, nY, FALSE);
  405. color = LIGHTRED;
  406. }
  407.  
  408. // Carry food toward queen ant
  409. void Worker::moveTowardQueen(void)
  410. {
  411.   int xDist, yDist;
  412.  
  413.   if (nX > gQueen->getX()) {
  414.      xDist = -1 * MIN(uMaxSpeed / 2, nX - gQueen->getX());
  415.   }
  416.   else 
  417.     if (nX < gQueen->getX()) {
  418.         xDist = MIN(uMaxSpeed / 2, gQueen->getX() - nX);
  419.     }
  420.     else {
  421.         xDist = 0;
  422.     }
  423.  
  424.   if (nY > gQueen->getY()) {
  425.       yDist = -1 * MIN(uMaxSpeed / 2, nY - gQueen->getY());
  426.   }
  427.   else 
  428.       if (nY < gQueen->getY()) {
  429.           yDist = MIN(uMaxSpeed / 2, gQueen->getY() - nY);
  430.       }
  431.       else {
  432.           yDist = 0;
  433.       }
  434.  
  435.   moveTo(nX + xDist, nY + yDist );
  436. }
  437.  
  438.  
  439. // Roam around randomly, looking for food
  440. void Worker::lookForFood(void)
  441. {
  442. if (!bEgg) {
  443.   move();
  444.   if (guFoodUnits[nX][nY]) {
  445.      grabFood();
  446.      }
  447.   }
  448. }
  449.  
  450. void Worker::doTheAntThing(void)
  451. {
  452. Ant::doTheAntThing(); // age, reduce energy, die if necessary
  453. if (nFood) {
  454.     if (distance(nX, nY, gQueen->getX(), gQueen->getY()) <= gnDropDistance) {
  455.         dropFood();
  456.         }
  457.     else {
  458.         moveTowardQueen();
  459.         }
  460.     }
  461. else {
  462.     lookForFood();
  463.     }
  464. }
  465.  
  466.  
  467. //////////////////////////////////////////////////////////////////////////
  468. //                                                                      //
  469. //                     CONSUMER class functions                         //
  470. //                                                                      //
  471. //////////////////////////////////////////////////////////////////////////
  472.  
  473. void Consumer::eatFood(int nUnits)
  474. {
  475.   int nX = getX();
  476.   int nY = getY();
  477.   nEnergy += MIN(nUnits, guFoodUnits[nX][nY]);
  478.   gulTotalFood -= MIN(nUnits, guFoodUnits[nX][nY]);
  479.   if (!(guFoodUnits[nX][nY] -= MIN(nUnits, guFoodUnits[nX][nY]))){
  480.      showFood(nX, nY, FALSE);
  481.   }
  482. }
  483.  
  484.  
  485.  
  486. //////////////////////////////////////////////////////////////////////////
  487. //                                                                      //
  488. //                           Support Functions                          //
  489. //                                                                      //
  490. //////////////////////////////////////////////////////////////////////////
  491.  
  492.  
  493. int distance(int nX1, int nY1, int nX2, int nY2)
  494. {
  495.   double sumSq = (double)((nX2-nX1)*(nX2-nX1) + (nY2-nY1)*(nY2-nY1));
  496.   if (sumSq > 0.0){
  497.     return((int) sqrt(sumSq));
  498.   }else{
  499.     return(0);
  500.   }
  501. }
  502.  
  503. void showFood(int nX, int nY, BOOLEAN bVisible)
  504. {
  505.   setfillstyle(SOLID_FILL, bVisible ? WHITE : BACKGROUND);
  506.   bar((nX + 0.5) * gfCellSizeX + 1,   nY * gfCellSizeY,
  507.       (nX + 1) * gfCellSizeX - 1, (nY + 1) * gfCellSizeY - 1);
  508. }
  509.  
  510. void showStatus(BOOLEAN bShowAll)
  511. {
  512.   char szMsg[100];
  513.  
  514.   setfillstyle(SOLID_FILL, BLACK);
  515.   if (bShowAll){
  516.     bar(0,getmaxy()-19,getmaxx(),getmaxy());
  517.     sprintf(szMsg, "Workers: %4u   Eggs: %4u   Food: %7lu    Cycle: %6lu   \
  518. Queen: %5d     <X-eXit>", guWorkers, guEggs, gulTotalFood, gulCycle++,
  519.             gQueen->nEnergy);
  520.     outtextxy(5,getmaxy()-16,szMsg);
  521.   }else{
  522.     sprintf(szMsg, "%4u", guWorkers);
  523.     bar(5+8*8, getmaxy()-19, 5+8*13, getmaxy());
  524.     outtextxy(5+8*8, getmaxy()-16, szMsg);
  525.  
  526.     sprintf(szMsg, "%4u", guEggs);
  527.     bar(5+8*20, getmaxy()-19, 5+8*24, getmaxy());
  528.     outtextxy(5+8*20, getmaxy()-16, szMsg);
  529.  
  530.     sprintf(szMsg, "%7lu", gulTotalFood);
  531.     bar(5+8*32, getmaxy()-19, 5+8*39, getmaxy());
  532.     outtextxy(5+8*32, getmaxy()-16, szMsg);
  533.  
  534.     sprintf(szMsg, "%6lu", gulCycle++);
  535.     bar(5+8*47, getmaxy()-19, 5+8*53, getmaxy());
  536.     outtextxy(5+8*47, getmaxy()-16, szMsg);
  537.  
  538.     sprintf(szMsg, "%5d", gQueen->nEnergy);
  539.     bar(5+8*61, getmaxy()-19, 5+8*67, getmaxy());
  540.     outtextxy(5+8*61, getmaxy()-16, szMsg);
  541.   }
  542. }
  543.  
  544. void runSimulation(void)
  545. {
  546.   int grMode, grDriver;      // Used to initialize graphics device
  547.   int nErrCode;              // Results of graphics operation
  548.   char ch;
  549.  
  550.  
  551.   // Clear out accumulators
  552.   headOfAntList = NULL;
  553.   gulTotalFood = 0L;
  554.   guWorkers = 0;
  555.   guEggs = 0;
  556.  
  557.   grDriver = DETECT;
  558.   initgraph(&grDriver, &grMode, "");
  559.  
  560.   nErrCode = graphresult();
  561.  
  562.   if (nErrCode != grOk){
  563.     printf("\n\nGraphics error: %s\n", grapherrormsg(nErrCode));
  564.   }else{
  565.      // Determine size of cells for 100 x 100 grid
  566.     gfCellSizeX = getmaxx() / 100.0;
  567.     gfCellSizeY = (getmaxy() - 20) / 100.0; // Allow room for status line
  568.  
  569.     // Draw line to seperate status area
  570.     line(0,getmaxy() - 20, getmaxx(), getmaxy() - 20);
  571.  
  572.     // Reset timer
  573.     gulCycle      = 0;      // Start timer at 0
  574.  
  575.  
  576.     // Create and show the queen ant
  577.      gQueen = new Queen( guQueensEnergy, 20, 2, 10, 10, guBirthRate );
  578.      gQueen->show();
  579.  
  580.     // Now the Worker ants and eggs will be created. The pointers to the
  581.     // newly created ants are not kept because they are automatically put
  582.     // in a doubly linked list by the constructor function. The head of the
  583.     // list is the global variable head.
  584.  
  585.     // Create worker ants
  586.     for (int i=0; i<guInitWorkers; i++){
  587.         Worker *temp = new Worker(FALSE, random(100), random(100));
  588.         temp->show();
  589.         guWorkers++;
  590.      }
  591.  
  592.     // Create the eggs
  593.     for (i=0; i<guInitEggs; i++){
  594.         Worker *temp = new Worker(TRUE, random(30), random(30));
  595.         temp->show();
  596.         guEggs++;
  597.      }
  598.  
  599.     // Create some food
  600.     for (i=0; i<100; i++){
  601.       for (int j=0; j<100; j++){
  602.         guFoodUnits[i][j] = 0;
  603.       }
  604.     }
  605.     for (i=0; i<guInitFood; i++){
  606.       int nY = random(100);
  607.       int nX = (nY>50) ? random(100) : (50 + random(50));
  608.       guFoodUnits[nX][nY] = random(1000) + 1000;
  609.       gulTotalFood += guFoodUnits[nX][nY];
  610.       showFood(nX, nY, TRUE);
  611.     }
  612.  
  613.     BOOLEAN bDone = FALSE;
  614.     showStatus(TRUE);
  615.  
  616.     while(!bDone){
  617.  
  618.       // Update status line
  619.       showStatus(FALSE);
  620.  
  621.       // Pause
  622.       delay(guPause);
  623.  
  624.       // Process the queen ant
  625.       if (!gQueen->bDead){
  626.         gQueen->doTheAntThing();
  627.       }
  628.  
  629.       // Process all ants that are in list
  630.         Worker *thisAnt = headOfAntList;
  631.         while(thisAnt != NULL){
  632.           Worker *nextWorker = thisAnt->next();
  633.           if (!thisAnt->bDead){
  634.              thisAnt->doTheAntThing();
  635.           }
  636.           if (thisAnt->bDead){
  637.              delete thisAnt;
  638.         }
  639.         thisAnt = nextWorker;
  640.       }
  641.  
  642.       // Are all ants dead?
  643.         if (gQueen->bDead && headOfAntList == NULL){
  644.         bDone = TRUE;
  645.         bar(5+8*67, getmaxy()-19, getmaxx(), getmaxy());
  646.         outtextxy(5+8*67,getmaxy()-16,"<Hit A Key>");
  647.         showStatus(FALSE);
  648.         sound(6000);
  649.         delay(1000);
  650.         nosound();
  651.         getch();
  652.       }
  653.  
  654.       // Has user hit X key?
  655.       if (kbhit()){
  656.         ch = toupper(getch());
  657.         bDone = (ch == 'X');
  658.         if (!bDone){
  659.           sound(1000);
  660.           delay(500);
  661.           nosound();
  662.         }
  663.       }
  664.     }
  665.  
  666.     delete gQueen;
  667.  
  668.     // Go back to original screen mode
  669.     closegraph();
  670.   }
  671. }
  672.  
  673. void resetDefaults(void)
  674. {
  675.   /////////////////////////////////////////////////////////////////
  676.   // These are the parameters to adjust to affect the simulation //
  677.   /////////////////////////////////////////////////////////////////
  678.   gnDropDistance   = 4;     // Drop food when distance 8 away from queen
  679.   gnTimeToHatch    = 20;    // Cycles to become a worker ant
  680.   guInitWorkers    = 2;     // Initial # of workers
  681.   guInitEggs       = 2;     // Initial # of eggs
  682.   guInitFood       = 400;   // Initial # of food cells
  683.   guPause          = 0;     // Milliseconds to pause each cycle
  684.   guWorkersPortion = 250;   // What a worker eats from each food cell found
  685.   guBirthRate      = 10;    // How many of 100 rounds does egg get laid
  686.   guMaxLifeSpan    = 200;   // Maximum age ant will live to
  687.   guMaxSpeed       = 2;     // Maximum speed that worker ant will move
  688.   guQueensEnergy   = 2000;  // Queens extra starting energy
  689. }
  690.  
  691. void displayValues(void)
  692. {
  693.   clrscr();
  694.   gotoxy(26,1);
  695.   printf("ANTHILL  by Mark Weaver & Alex Lane");
  696.   gotoxy(35,24);
  697.   printf("SELECT ONE");
  698.  
  699.   gotoxy(2,5);
  700.   printf("[W]               initial number of Worker ants");
  701.   gotoxy(2,6);
  702.   printf("[E]               initial number of Eggs");
  703.   gotoxy(2,7);
  704.   printf("[F]               initial number of cells containing Food");
  705.   gotoxy(2,8);
  706.   printf("[B]               Birth rate (chance in 100 of a birth each cycle)");
  707.   gotoxy(2,9);
  708.   printf("[L]               worker ant's maximum Life span");
  709.   gotoxy(2,10);
  710.   printf("[V]               worker ant's maximum Velocity (cells per cycle)");
  711.   gotoxy(2,11);
  712.   printf("[P]               Portion of food worker eats each time food is \
  713. found");
  714.   gotoxy(2,12);
  715.   printf("[H]               number of cycles it takes an egg to Hatch");
  716.   gotoxy(2,13);
  717.   printf("[Q]               Queens initial energy level");
  718.   gotoxy(2,14);
  719.   printf("[D]               Delay between each cycle (in milliseconds)");
  720.   gotoxy(2,16);
  721.   printf("[R]               Run simulation");
  722.   gotoxy(2,17);
  723.   printf("[X]               eXit to DOS");
  724.  
  725.   gotoxy(7,5);
  726.   printf("%5u", guInitWorkers);
  727.   gotoxy(7,6);
  728.   printf("%5u", guInitEggs);
  729.   gotoxy(7,7);
  730.   printf("%5u", guInitFood);
  731.   gotoxy(7,8);
  732.   printf("%5u", guBirthRate);
  733.   gotoxy(7,9);
  734.   printf("%5u", guMaxLifeSpan);
  735.   gotoxy(7,10);
  736.   printf("%5u", guMaxSpeed);
  737.   gotoxy(7,11);
  738.   printf("%5u", guWorkersPortion);
  739.   gotoxy(7,12);
  740.   printf("%5u", gnTimeToHatch);
  741.   gotoxy(7,13);
  742.   printf("%5u", guQueensEnergy);
  743.   gotoxy(7,14);
  744.   printf("%5u", guPause);
  745. }
  746.  
  747. unsigned getNumber(char *szPrompt, unsigned nMin, unsigned nMax, 
  748.                    unsigned nDefault)
  749. {
  750.   char szBuff[500];
  751.   int nRetval;
  752.   
  753.  
  754.   gotoxy(1,20);
  755.   clreol();
  756.   gotoxy(1,21);
  757.   clreol();
  758.   gotoxy(1,20);
  759.   printf("%s", szPrompt);
  760.   gotoxy(1,21);
  761.   printf("Range (%u to %u), <Return> for %u : ", nMin, nMax, nDefault);
  762.   gets(szBuff);
  763.   gotoxy(1,20);
  764.   clreol();
  765.   gotoxy(1,21);
  766.   clreol();
  767.  
  768.   // strip off leading spaces
  769.   char *ptr = szBuff;
  770.   while(*ptr == ' '){
  771.     ptr++;
  772.   }
  773.  
  774.   if (*ptr == '\0'){
  775.     return(nDefault);
  776.   }else{
  777.     sscanf(ptr, "%d", &nRetval);
  778.     return(nRetval);
  779.   }
  780.  
  781. }
  782.  
  783. char getChoice(void)
  784. {
  785.   char chRetval = ' ';
  786.  
  787.   while (strchr("WEFBLVPHQDRX", chRetval) == NULL){
  788.     chRetval = toupper(getch());
  789.   }
  790.   return(chRetval);
  791. }
  792.  
  793.  
  794. //////////////////////////////////////////////////////////////////////////
  795. //                                                                      //
  796. //                            Main Program                              // 
  797. //                                                                      //
  798. //////////////////////////////////////////////////////////////////////////
  799.  
  800. main()
  801. {
  802.  
  803.   // Initialize random number generator
  804.   randomize();
  805.  
  806.   resetDefaults();
  807.  
  808.   BOOLEAN bDone = FALSE;
  809.   while(!bDone){
  810.     displayValues();
  811.     char ch = getChoice();
  812.     switch(ch){
  813.       case 'X':
  814.         bDone = TRUE;
  815.         break;
  816.  
  817.       case 'H':   // hatch time
  818.         gnTimeToHatch = getNumber("Enter the number of cycles it takes an \
  819. egg to hatch",
  820.                                  5, 100, gnTimeToHatch);
  821.         break;
  822.  
  823.       case 'W':   // Initial workers
  824.         guInitWorkers = getNumber("Enter initial number of worker ants",
  825.                                    0, 100, guInitWorkers);
  826.         break;
  827.  
  828.       case 'E':   // Initial eggs
  829.         guInitEggs = getNumber("Enter initial number of worker eggs",
  830.                                    0, 100, guInitEggs);
  831.         break;
  832.  
  833.       case 'F':   // Initial number of food cells
  834.         guInitFood = getNumber("Enter number of cells initially containing \
  835. food",
  836.                            0, 1000, guInitFood);
  837.         break;
  838.  
  839.       case 'B':   // Birth rate
  840.         guBirthRate = getNumber("Enter percentage chance of a birth each cycle",
  841.                                             5, 50, guBirthRate);
  842.         break;
  843.  
  844.       case 'V':   // Max velocity
  845.         guMaxSpeed = getNumber("Enter workers maximum speed", 1, 20,
  846.                                   guMaxSpeed);
  847.         break;
  848.  
  849.       case 'Q':   // Queens start energy
  850.         guQueensEnergy = getNumber("Enter queens initial energy level",
  851.                                    1000, 100000, guQueensEnergy);
  852.         break;
  853.  
  854.       case 'L':   // Max worker lifespan
  855.         guMaxLifeSpan = getNumber("Enter maximum lifespan of worker ants",
  856.                                    50, 500, guMaxLifeSpan);
  857.         break;
  858.  
  859.       case 'P':   // Workers portion of food
  860.         guWorkersPortion = getNumber("Enter amount of food a worker eats \
  861. each time it finds some food",
  862.                                      0, 500, guWorkersPortion);
  863.         break;
  864.  
  865.       case 'D':   // Delay between each round
  866.         guPause = getNumber("Enter delay for each cycle in milliseconds",
  867.                             0, 10000, guPause);
  868.         break;
  869.  
  870.       case 'R':   // Run simulation
  871.         runSimulation();
  872.         break;
  873.     }
  874.   }
  875.   clrscr();
  876. }
  877.